// PDF 模块中文API封装 - 基于pdfmake库（完整版本，包含创建和基本操作功能）
const fs = require('fs');
const path = require('path');

// 注意：此模块需要安装 pdfmake 库
// npm install pdfmake
let pdfMake;
try {
  pdfMake = require('pdfmake');
} catch (e) {
  console.warn('警告: 未安装 pdfmake 库，请运行 "npm install pdfmake" 来安装');
}

// 注意：对于PDF读取和操作功能，建议安装以下额外库：
// - pdf-parse: 用于解析PDF内容
// - hummus: 用于PDF合并、分割等操作
// - pdf-image: 用于PDF转图片
let pdfParse;
let hummus;
try {
  pdfParse = require('pdf-parse');
} catch (e) {
  // 可选依赖，不抛出错误
}
try {
  hummus = require('hummus');
} catch (e) {
  // 可选依赖，不抛出错误
}

/**
   * 验证可选库是否可用
   * @param {string} 库名 - 库名称
   * @param {Object} 库对象 - 库对象引用
   * @returns {boolean} 库是否可用
   */
  function 验证可选库(库名, 库对象) {
    if (!库对象) {
      console.warn(`警告: 未安装 ${库名} 库，请运行 "npm install ${库名}" 来使用此功能`);
      return false;
    }
    return true;
  }

  /**
   * 读取PDF文件
   * @param {string} 文件路径 - PDF文件路径
   * @returns {Promise<Object>} PDF文档对象
   */
  async function 读取PDF文件(文件路径) {
    try {
      const buffer = await fs.promises.readFile(文件路径);
      return await 从Buffer读取PDF(buffer);
    } catch (错误) {
      throw new Error(`读取PDF文件失败: ${错误.message}`);
    }
  }

  /**
   * 从Buffer读取PDF
   * @param {Buffer} 缓冲区 - PDF文件的Buffer数据
   * @returns {Promise<Object>} PDF文档对象
   */
  async function 从Buffer读取PDF(缓冲区) {
    if (!验证可选库('pdf-parse', pdfParse)) {
      // 如果没有pdf-parse库，返回基本的Buffer包装
      return {
        buffer: 缓冲区,
        info: { size: 缓冲区.length, type: 'PDF' },
        警告: '未安装pdf-parse库，无法解析PDF内容'
      };
    }

    try {
      const 数据 = await pdfParse(缓冲区);
      return {
        buffer: 缓冲区,
        info: 数据.info,
        metadata: 数据.metadata,
        text: 数据.text,
        numpages: 数据.numpages,
        numrender: 数据.numrender,
        version: 数据.version
      };
    } catch (错误) {
      throw new Error(`从Buffer读取PDF失败: ${错误.message}`);
    }
  }

  /**
   * 解析PDF文本内容
   * @param {string|Buffer} PDF数据 - PDF文件路径或Buffer
   * @returns {Promise<string>} PDF文本内容
   */
  async function 解析PDF文本内容(PDF数据) {
    if (!验证可选库('pdf-parse', pdfParse)) {
      throw new Error('未安装pdf-parse库，无法解析PDF文本内容');
    }

    try {
      let buffer;
      if (typeof PDF数据 === 'string') {
        buffer = await fs.promises.readFile(PDF数据);
      } else if (Buffer.isBuffer(PDF数据)) {
        buffer = PDF数据;
      } else {
        throw new Error('PDF数据必须是文件路径或Buffer');
      }

      const 数据 = await pdfParse(buffer);
      return 数据.text;
    } catch (错误) {
      throw new Error(`解析PDF文本内容失败: ${错误.message}`);
    }
  }

  /**
   * 提取PDF页面
   * @param {string} 源文件路径 - 源PDF文件路径
   * @param {string} 目标文件路径 - 目标PDF文件路径
   * @param {Array} 页面范围 - 要提取的页面数组，如[1,3,5]
   * @returns {Promise<void>}
   */
  async function 提取PDF页面(源文件路径, 目标文件路径, 页面范围) {
    if (!验证可选库('hummus', hummus)) {
      throw new Error('未安装hummus库，无法提取PDF页面');
    }

    try {
      // 使用hummus提取页面
      const pdfWriter = hummus.createWriter(目标文件路径);
      const pdfReader = hummus.createReader(源文件路径);
      const totalPages = pdfReader.getPagesCount();

      页面范围.forEach(pageNum => {
        // PDF页码从1开始
        if (pageNum >= 1 && pageNum <= totalPages) {
          pdfWriter.appendPDFPageFromPDF(源文件路径, pdfWriter.createPage(), {type: hummus.eRangeTypeSpecific, specificRanges: [{firstPage: pageNum - 1, lastPage: pageNum - 1}]});
        }
      });

      pdfWriter.end();
    } catch (错误) {
      throw new Error(`提取PDF页面失败: ${错误.message}`);
    }
  }

  /**
   * 提取PDF图片
   * @param {string|Buffer} PDF数据 - PDF文件路径或Buffer
   * @param {string} 输出目录 - 图片保存目录
   * @returns {Promise<Array>} 提取的图片信息数组
   */
  async function 提取PDF图片(PDF数据, 输出目录) {
    if (!验证可选库('pdf-parse', pdfParse)) {
      throw new Error('提取PDF图片需要额外的库支持');
    }

    try {
      // 确保输出目录存在
      if (!fs.existsSync(输出目录)) {
        await fs.promises.mkdir(输出目录, { recursive: true });
      }

      console.warn('警告: 完整的PDF图片提取功能需要额外的专门库支持');
      return [];
    } catch (错误) {
      throw new Error(`提取PDF图片失败: ${错误.message}`);
    }
  }

  /**
   * 获取PDF页面数
   * @param {string|Buffer} PDF数据 - PDF文件路径或Buffer
   * @returns {Promise<number>} PDF页面数
   */
  async function 获取PDF页面数(PDF数据) {
    if (!验证可选库('pdf-parse', pdfParse)) {
      throw new Error('未安装pdf-parse库，无法获取PDF页面数');
    }

    try {
      let buffer;
      if (typeof PDF数据 === 'string') {
        buffer = await fs.promises.readFile(PDF数据);
      } else if (Buffer.isBuffer(PDF数据)) {
        buffer = PDF数据;
      } else {
        throw new Error('PDF数据必须是文件路径或Buffer');
      }

      const 数据 = await pdfParse(buffer);
      return 数据.numpages || 0;
    } catch (错误) {
      throw new Error(`获取PDF页面数失败: ${错误.message}`);
    }
  }

  /**
   * 获取PDF元数据
   * @param {string|Buffer} PDF数据 - PDF文件路径或Buffer
   * @returns {Promise<Object>} PDF元数据
   */
  async function 获取PDF元数据(PDF数据) {
    if (!验证可选库('pdf-parse', pdfParse)) {
      throw new Error('未安装pdf-parse库，无法获取PDF元数据');
    }

    try {
      let buffer;
      if (typeof PDF数据 === 'string') {
        buffer = await fs.promises.readFile(PDF数据);
      } else if (Buffer.isBuffer(PDF数据)) {
        buffer = PDF数据;
      } else {
        throw new Error('PDF数据必须是文件路径或Buffer');
      }

      const 数据 = await pdfParse(buffer);
      return {
        info: 数据.info || {},
        metadata: 数据.metadata || {}
      };
    } catch (错误) {
      throw new Error(`获取PDF元数据失败: ${错误.message}`);
    }
  }

  /**
   * 合并PDF文档
   * @param {Array} 文件路径数组 - PDF文件路径数组
   * @param {string} 输出文件路径 - 合并后的PDF文件路径
   * @returns {Promise<void>}
   */
  async function 合并PDF文档(文件路径数组, 输出文件路径) {
    if (!验证可选库('hummus', hummus)) {
      throw new Error('未安装hummus库，无法合并PDF文档');
    }

    try {
      const pdfWriter = hummus.createWriter(输出文件路径);

      文件路径数组.forEach(filePath => {
        pdfWriter.appendPDFPagesFromPDF(filePath);
      });

      pdfWriter.end();
    } catch (错误) {
      throw new Error(`合并PDF文档失败: ${错误.message}`);
    }
  }

  /**
   * 分割PDF文档
   * @param {string} 源文件路径 - 源PDF文件路径
   * @param {string} 输出目录 - 输出目录
   * @param {Object} 分割选项 - 分割选项
   * @returns {Promise<Array>} 分割后的文件路径数组
   */
  async function 分割PDF文档(源文件路径, 输出目录, 分割选项 = {}) {
    if (!验证可选库('hummus', hummus)) {
      throw new Error('未安装hummus库，无法分割PDF文档');
    }

    try {
      // 确保输出目录存在
      if (!fs.existsSync(输出目录)) {
        await fs.promises.mkdir(输出目录, { recursive: true });
      }

      const pdfReader = hummus.createReader(源文件路径);
      const totalPages = pdfReader.getPagesCount();
      const 分割文件列表 = [];

      // 按页分割
      for (let i = 0; i < totalPages; i++) {
        const 输出文件路径 = path.join(输出目录, `page_${i + 1}.pdf`);
        const pdfWriter = hummus.createWriter(输出文件路径);
        pdfWriter.appendPDFPageFromPDF(源文件路径, pdfWriter.createPage(), {type: hummus.eRangeTypeSpecific, specificRanges: [{firstPage: i, lastPage: i}]});
        pdfWriter.end();
        分割文件列表.push(输出文件路径);
      }

      return 分割文件列表;
    } catch (错误) {
      throw new Error(`分割PDF文档失败: ${错误.message}`);
    }
  }

  /**
   * 添加PDF水印
   * @param {string} 源文件路径 - 源PDF文件路径
   * @param {string} 输出文件路径 - 输出PDF文件路径
   * @param {string} 水印文本 - 水印文本
   * @param {Object} 水印选项 - 水印选项
   * @returns {Promise<void>}
   */
  async function 添加PDF水印(源文件路径, 输出文件路径, 水印文本, 水印选项 = {}) {
    if (!验证可选库('hummus', hummus)) {
      throw new Error('未安装hummus库，无法添加PDF水印');
    }

    try {
      const pdfWriter = hummus.createWriterToModify(源文件路径, {
        modifiedFilePath: 输出文件路径
      });

      const pdfReader = pdfWriter.getModifiedFileParser();
      const totalPages = pdfReader.getPagesCount();

      for (let i = 0; i < totalPages; i++) {
        const pageModifier = new hummus.PDFPageModifier(pdfWriter, i, true);
        const context = pageModifier.startContext().getContext();
        const pageSize = pdfReader.parsePage(i).getMediaBox();

        // 保存当前状态
        context.save();
        
        // 设置水印文本属性
        context.setFontAndSize('Helvetica', 48);
        context.setFillColor(水印选项.颜色 || 0xCCCCCC);
        
        // 计算水印位置和角度
        const centerX = (pageSize[2] - pageSize[0]) / 2;
        const centerY = (pageSize[3] - pageSize[1]) / 2;
        
        // 旋转文本
        context.transform(1, 0, 0, 1, centerX, centerY);
        context.rotate(Math.PI / 4); // 45度角
        context.transform(1, 0, 0, 1, -context.stringWidth(水印文本) / 2, 0);
        
        // 绘制文本
        context.fillText(水印文本, 0, 0);
        
        // 恢复状态
        context.restore();
        
        // 写入修改
        pageModifier.endContext().writePage();
      }

      pdfWriter.end();
    } catch (错误) {
      throw new Error(`添加PDF水印失败: ${错误.message}`);
    }
  }

  /**
   * 添加PDF页码
   * @param {string} 源文件路径 - 源PDF文件路径
   * @param {string} 输出文件路径 - 输出PDF文件路径
   * @param {Object} 页码选项 - 页码选项
   * @returns {Promise<void>}
   */
  async function 添加PDF页码(源文件路径, 输出文件路径, 页码选项 = {}) {
    if (!验证可选库('hummus', hummus)) {
      throw new Error('未安装hummus库，无法添加PDF页码');
    }

    try {
      const pdfWriter = hummus.createWriterToModify(源文件路径, {
        modifiedFilePath: 输出文件路径
      });

      const pdfReader = pdfWriter.getModifiedFileParser();
      const totalPages = pdfReader.getPagesCount();
      const 起始页码 = 页码选项.起始页码 || 1;
      const 页码格式 = 页码选项.格式 || '第 ${page} 页，共 ${total} 页';

      for (let i = 0; i < totalPages; i++) {
        const currentPage = i + 起始页码;
        const pageModifier = new hummus.PDFPageModifier(pdfWriter, i, true);
        const context = pageModifier.startContext().getContext();
        const pageSize = pdfReader.parsePage(i).getMediaBox();

        // 设置页码文本
        const pageText = 页码格式.replace('${page}', currentPage).replace('${total}', totalPages);
        
        // 设置文本属性
        context.setFontAndSize('Helvetica', 页码选项.字号 || 10);
        context.setFillColor(页码选项.颜色 || 0x000000);
        
        // 计算文本宽度
        const textWidth = context.stringWidth(pageText);
        
        // 计算位置（默认居中底部）
        const x = (pageSize[2] - pageSize[0] - textWidth) / 2;
        const y = 页码选项.垂直位置 || 20;
        
        // 绘制页码
        context.fillText(pageText, x, y);
        
        // 写入修改
        pageModifier.endContext().writePage();
      }

      pdfWriter.end();
    } catch (错误) {
      throw new Error(`添加PDF页码失败: ${错误.message}`);
    }
  }

  /**
   * PDF加密
   * @param {string} 源文件路径 - 源PDF文件路径
   * @param {string} 输出文件路径 - 输出PDF文件路径
   * @param {string} 用户密码 - 用户密码（打开密码）
   * @param {string} 所有者密码 - 所有者密码（完全权限）
   * @param {Object} 权限选项 - 权限选项
   * @returns {Promise<void>}
   */
  async function PDF加密(源文件路径, 输出文件路径, 用户密码, 所有者密码, 权限选项 = {}) {
    if (!验证可选库('hummus', hummus)) {
      throw new Error('未安装hummus库，无法加密PDF');
    }

    try {
      // 注意：hummus的加密功能需要专业版本，这里提供基本实现
      console.warn('警告: hummus库的完整PDF加密功能可能需要专业版本');
      
      // 简单的复制操作，实际应用中需要使用支持加密的库
      await fs.promises.copyFile(源文件路径, 输出文件路径);
      console.warn('信息: PDF文件已复制，但未加密，请使用支持加密的PDF库');
    } catch (错误) {
      throw new Error(`PDF加密失败: ${错误.message}`);
    }
  }

  /**
   * PDF解密
   * @param {string} 源文件路径 - 源PDF文件路径
   * @param {string} 输出文件路径 - 输出PDF文件路径
   * @param {string} 密码 - 解密密码
   * @returns {Promise<void>}
   */
  async function PDF解密(源文件路径, 输出文件路径, 密码) {
    console.warn('警告: PDF解密功能需要专门的库支持');
    throw new Error('PDF解密功能需要专门的库支持，如node-qpdf');
  }

  /**
   * 旋转PDF页面
   * @param {string} 源文件路径 - 源PDF文件路径
   * @param {string} 输出文件路径 - 输出PDF文件路径
   * @param {number} 角度 - 旋转角度（90、180、270）
   * @param {Array} 页面范围 - 要旋转的页面数组，默认为所有页面
   * @returns {Promise<void>}
   */
  async function 旋转PDF页面(源文件路径, 输出文件路径, 角度, 页面范围) {
    if (!验证可选库('hummus', hummus)) {
      throw new Error('未安装hummus库，无法旋转PDF页面');
    }

    try {
      const pdfWriter = hummus.createWriterToModify(源文件路径, {
        modifiedFilePath: 输出文件路径
      });

      const pdfReader = pdfWriter.getModifiedFileParser();
      const totalPages = pdfReader.getPagesCount();
      const 所有页面 = Array.from({ length: totalPages }, (_, i) => i + 1);
      const 目标页面 = 页面范围 || 所有页面;

      for (let i = 0; i < totalPages; i++) {
        if (目标页面.includes(i + 1)) {
          const pageModifier = new hummus.PDFPageModifier(pdfWriter, i, true);
          const page = pdfReader.parsePage(i);
          const pageSize = page.getMediaBox();
          
          // 创建新的旋转页面
          const newPage = pdfWriter.createPage({
            mediaBox: [0, 0, pageSize[2] - pageSize[0], pageSize[3] - pageSize[1]]
          });
          
          // 添加旋转属性
          newPage.addRotation(角度);
          
          // 复制内容
          pageModifier.writePage(newPage);
        }
      }

      pdfWriter.end();
    } catch (错误) {
      throw new Error(`旋转PDF页面失败: ${错误.message}`);
    }
  }

  /**
   * 压缩PDF文件
   * @param {string} 源文件路径 - 源PDF文件路径
   * @param {string} 输出文件路径 - 输出PDF文件路径
   * @param {Object} 压缩选项 - 压缩选项
   * @returns {Promise<void>}
   */
  async function 压缩PDF文件(源文件路径, 输出文件路径, 压缩选项 = {}) {
    console.warn('警告: PDF压缩功能需要专门的库支持');
    throw new Error('PDF压缩功能需要专门的库支持，如ghostscript4js');
  }

  /**
   * PDF转图片
   * @param {string} 源文件路径 - 源PDF文件路径
   * @param {string} 输出目录 - 输出目录
   * @param {Object} 转换选项 - 转换选项
   * @returns {Promise<Array>} 生成的图片文件路径数组
   */
  async function PDF转图片(源文件路径, 输出目录, 转换选项 = {}) {
    console.warn('警告: PDF转图片功能需要专门的库支持');
    throw new Error('PDF转图片功能需要专门的库支持，如pdf-image或sharp');
  }

  /**
   * PDF转HTML
   * @param {string} 源文件路径 - 源PDF文件路径
   * @param {string} 输出文件路径 - 输出HTML文件路径
   * @returns {Promise<void>}
   */
  async function PDF转HTML(源文件路径, 输出文件路径) {
    console.warn('警告: PDF转HTML功能需要专门的库支持');
    throw new Error('PDF转HTML功能需要专门的库支持');
  }

  /**
   * PDF转文本
   * @param {string|Buffer} PDF数据 - PDF文件路径或Buffer
   * @returns {Promise<string>} 转换后的文本
   */
  async function PDF转文本(PDF数据) {
    // 复用现有的解析功能
    return await 解析PDF文本内容(PDF数据);
  }

  /**
   * 比较PDF文档
   * @param {string} 文件路径1 - 第一个PDF文件路径
   * @param {string} 文件路径2 - 第二个PDF文件路径
   * @returns {Promise<Object>} 比较结果
   */
  async function 比较PDF文档(文件路径1, 文件路径2) {
    try {
      const 文本1 = await 解析PDF文本内容(文件路径1);
      const 文本2 = await 解析PDF文本内容(文件路径2);
      
      return {
        文本相同: 文本1 === 文本2,
        文本长度差异: 文本1.length - 文本2.length,
        文本1长度: 文本1.length,
        文本2长度: 文本2.length
      };
    } catch (错误) {
      throw new Error(`比较PDF文档失败: ${错误.message}`);
    }
  }

  /**
   * 创建字体定义对象
   * @param {Object} 字体选项 - 字体配置选项
   * @returns {Object} 字体定义对象
   */
function 创建字体定义(字体选项 = {}) {
  const 字体定义 = {};
  
  // 默认字体（pdfmake内置）
  if (字体选项.使用默认字体 !== false) {
    字体定义.Roboto = {
      normal: 'Helvetica',
      bold: 'Helvetica-Bold',
      italics: 'Helvetica-Oblique',
      bolditalics: 'Helvetica-BoldOblique'
    };
  }
  
  // 自定义字体
  if (字体选项.自定义字体) {
    Object.assign(字体定义, 字体选项.自定义字体);
  }
  
  return 字体定义;
}

/**
 * 创建新的PDF文档定义
 * @param {Object} 内容 - PDF内容定义
 * @param {Object} 选项 - 文档选项
 * @returns {Object} PDF文档定义
 */
function 创建PDF文档定义(内容 = {}, 选项 = {}) {
  try {
    const 文档定义 = {
      content: Array.isArray(内容) ? 内容 : [内容],
      pageSize: 选项.页面尺寸 || 'A4',
      pageOrientation: 选项.页面方向 || 'portrait',
      pageMargins: 选项.页面边距 || [40, 60, 40, 60],
      defaultStyle: 选项默认样式 || {},
      // 添加样式系统
      styles: 选项.样式 || {},
      // 添加段落样式
      paragraphStyles: 选项.段落样式 || {},
      // 添加标题样式
      headerStyles: 选项.标题样式 || {},
      // 添加页脚样式
      footerStyles: 选项.页脚样式 || {},
      // 添加表格样式
      tableLayouts: 选项.表格布局 || {},
      // 添加背景层
      background: 选项.背景 || null,
      // 添加自动生成目录
      toc: 选项.目录 || null,
      // 添加页面事件处理
      pageBreakBefore: 选项.页面断开处理函数,
      // 添加页面事件回调
      pageMargins: 选项.页面边距 || [40, 60, 40, 60]
    };
    
    // 添加页头
    if (选项.页头) {
      文档定义.header = 选项.页头;
    }
    
    // 添加页脚
    if (选项.页脚) {
      文档定义.footer = 选项.页脚;
    }
    
    return 文档定义;
  } catch (错误) {
    throw new Error(`创建PDF文档定义失败: ${错误.message}`);
  }
}

/**
 * 生成PDF并保存到文件
 * @param {Object} 文档定义 - PDF文档定义对象
 * @param {string} 文件路径 - 保存路径
 * @param {Object} 字体选项 - 字体选项
 * @returns {Promise<void>}
 */
async function 生成并保存PDF(文档定义, 文件路径, 字体选项 = {}) {
  try {
    if (!pdfMake) {
      throw new Error('pdfmake 库未安装');
    }
    
    const 字体定义 = 创建字体定义(字体选项);
    const pdfDocGenerator = pdfMake.createPdf(文档定义, {}, 字体定义);
    
    return new Promise((resolve, reject) => {
      pdfDocGenerator.getBuffer((buffer) => {
        try {
          fs.writeFileSync(文件路径, buffer);
          resolve();
        } catch (错误) {
          reject(new Error(`保存PDF文件失败: ${错误.message}`));
        }
      });
    });
  } catch (错误) {
    throw new Error(`生成PDF失败: ${错误.message}`);
  }
}

/**
 * 生成PDF并获取Buffer
 * @param {Object} 文档定义 - PDF文档定义对象
 * @param {Object} 字体选项 - 字体选项
 * @returns {Promise<Buffer>} PDF文件的Buffer
 */
async function 生成PDFBuffer(文档定义, 字体选项 = {}) {
  try {
    if (!pdfMake) {
      throw new Error('pdfmake 库未安装');
    }
    
    const 字体定义 = 创建字体定义(字体选项);
    const pdfDocGenerator = pdfMake.createPdf(文档定义, {}, 字体定义);
    
    return new Promise((resolve, reject) => {
      pdfDocGenerator.getBuffer((buffer) => {
        resolve(buffer);
      });
    });
  } catch (错误) {
    throw new Error(`生成PDF Buffer失败: ${错误.message}`);
  }
}

/**
 * 生成PDF并获取Base64字符串
 * @param {Object} 文档定义 - PDF文档定义对象
 * @param {Object} 字体选项 - 字体选项
 * @returns {Promise<string>} PDF文件的Base64字符串
 */
async function 生成PDFBase64(文档定义, 字体选项 = {}) {
  try {
    const buffer = await 生成PDFBuffer(文档定义, 字体选项);
    return buffer.toString('base64');
  } catch (错误) {
    throw new Error(`生成PDF Base64失败: ${错误.message}`);
  }
}

/**
 * 流式输出PDF到HTTP响应
 * @param {Object} 文档定义 - PDF文档定义对象
 * @param {Object} 响应对象 - Express/Node.js响应对象
 * @param {Object} 字体选项 - 字体选项
 * @returns {void}
 */
function 流式输出PDF到响应(文档定义, 响应对象, 字体选项 = {}) {
  try {
    if (!pdfMake) {
      throw new Error('pdfmake 库未安装');
    }
    
    const 字体定义 = 创建字体定义(字体选项);
    const pdfDocGenerator = pdfMake.createPdf(文档定义, {}, 字体定义);
    pdfDocGenerator.pipe(响应对象);
    pdfDocGenerator.end();
  } catch (错误) {
    throw new Error(`流式输出PDF失败: ${错误.message}`);
  }
}

/**
 * 流式输出PDF到可写流
 * @param {Object} 文档定义 - PDF文档定义对象
 * @param {Object} 可写流 - Node.js可写流对象
 * @param {Object} 字体选项 - 字体选项
 * @returns {void}
 */
function 流式输出PDF到流(文档定义, 可写流, 字体选项 = {}) {
  try {
    if (!pdfMake) {
      throw new Error('pdfmake 库未安装');
    }
    
    const 字体定义 = 创建字体定义(字体选项);
    const pdfDocGenerator = pdfMake.createPdf(文档定义, {}, 字体定义);
    pdfDocGenerator.pipe(可写流);
    pdfDocGenerator.end();
  } catch (错误) {
    throw new Error(`流式输出PDF失败: ${错误.message}`);
  }
}

/**
 * 创建文本元素
 * @param {string|Array} 文本内容 - 文本内容或文本元素数组
 * @param {Object} 样式选项 - 文本样式选项
 * @returns {Object|Array} 文本元素
 */
function 创建文本元素(文本内容, 样式选项 = {}) {
  if (Array.isArray(文本内容)) {
    // 如果是数组，每个元素可能已经包含样式
    return 文本内容.map(item => {
      if (typeof item === 'string') {
        return { text: item, ...样式选项 };
      }
      return { ...item, ...样式选项 };
    });
  }
  
  return { text: 文本内容, ...样式选项 };
}

/**
 * 创建段落元素
 * @param {Array} 段落内容 - 段落内容数组
 * @param {Object} 样式选项 - 段落样式选项
 * @returns {Object} 段落元素
 */
function 创建段落(段落内容, 样式选项 = {}) {
  return {
    text: 段落内容,
    ...样式选项
  };
}

/**
 * 创建标题元素
 * @param {string} 标题文本 - 标题文本
 * @param {number} 级别 - 标题级别（1-6）
 * @param {Object} 样式选项 - 标题样式选项
 * @returns {Object} 标题元素
 */
function 创建标题(标题文本, 级别 = 1, 样式选项 = {}) {
  const 默认样式 = {
    bold: true,
    fontSize: Math.max(14, 24 - 级别 * 2),
    margin: [0, 10, 0, 5]
  };
  
  return {
    text: 标题文本,
    style: `header${级别}`,
    ...默认样式,
    ...样式选项
  };
}

/**
 * 创建图片元素
 * @param {string|Buffer} 图片数据 - 图片路径或Base64字符串或Buffer
 * @param {Object} 样式选项 - 图片样式选项
 * @returns {Object} 图片元素
 */
function 创建图片元素(图片数据, 样式选项 = {}) {
  let 图像数据;
  
  if (typeof 图片数据 === 'string') {
    // 检查是否是文件路径
    if (fs.existsSync(图片数据)) {
      const buffer = fs.readFileSync(图片数据);
      const 扩展名 = path.extname(图片数据).toLowerCase();
      const mimeType = 扩展名 === '.jpg' || 扩展名 === '.jpeg' ? 'image/jpeg' : 
                       扩展名 === '.gif' ? 'image/gif' : 
                       扩展名 === '.svg' ? 'image/svg+xml' : 'image/png';
      图像数据 = `data:${mimeType};base64,${buffer.toString('base64')}`;
    } else {
      // 假设是Base64字符串
      图像数据 = 图片数据;
    }
  } else if (Buffer.isBuffer(图片数据)) {
    图像数据 = `data:image/png;base64,${图片数据.toString('base64')}`;
  } else {
    throw new Error('图片数据必须是文件路径、Base64字符串或Buffer');
  }
  
  return {
    image: 图像数据,
    ...样式选项
  };
}

/**
 * 创建表格元素
 * @param {Array} 表格数据 - 表格数据数组
 * @param {Object} 样式选项 - 表格样式选项
 * @returns {Object} 表格元素
 */
function 创建表格(表格数据, 样式选项 = {}) {
  return {
    table: {
      body: 表格数据,
      widths: 样式选项.宽度,
      headerRows: 样式选项.表头行数 || 1,
      keepWithHeaderRows: 样式选项.保持表头行数 || 1
    },
    ...样式选项
  };
}

/**
 * 创建高级表格布局
 * @param {Object} 布局选项 - 表格布局选项
 * @returns {Object} 表格布局对象
 */
function 创建表格布局(布局选项 = {}) {
  return {
    // 单元格边距
    hLineWidth: (i, node) => (i === 0 || i === node.table.body.length) ? 2 : 1,
    vLineWidth: (i, node) => (i === 0 || i === node.table.widths.length) ? 2 : 1,
    hLineColor: (i, node) => (i === 0 || i === node.table.body.length) ? 'black' : '#aaa',
    vLineColor: (i, node) => (i === 0 || i === node.table.widths.length) ? 'black' : '#aaa',
    paddingLeft: (i, node) => 10,
    paddingRight: (i, node) => 10,
    paddingTop: (i, node) => 8,
    paddingBottom: (i, node) => 8,
    ...布局选项
  };
}

/**
 * 创建列表元素
 * @param {Array} 列表项 - 列表项数组
 * @param {Object} 样式选项 - 列表样式选项
 * @returns {Object} 列表元素
 */
function 创建列表(列表项, 样式选项 = {}) {
  const 列表类型 = 样式选项.类型 || 'unordered';
  
  return {
    [列表类型]: 列表项,
    ...样式选项
  };
}

/**
 * 创建列元素
 * @param {Array} 列内容 - 列内容数组
 * @param {Object} 样式选项 - 列样式选项
 * @returns {Object} 列元素
 */
function 创建列(列内容, 样式选项 = {}) {
  return {
    columns: 列内容,
    columnGap: 样式选项.列间距 || 15,
    ...样式选项
  };
}

/**
 * 创建二维码元素
 * @param {string} 二维码内容 - 二维码内容
 * @param {Object} 样式选项 - 二维码样式选项
 * @returns {Object} 二维码元素
 */
function 创建二维码(二维码内容, 样式选项 = {}) {
  return {
    qr: 二维码内容,
    fit: 样式选项.大小 || 100,
    ...样式选项
  };
}

/**
 * 创建条形码元素
 * @param {string} 条形码内容 - 条形码内容
 * @param {Object} 样式选项 - 条形码样式选项
 * @returns {Object} 条形码元素
 */
function 创建条形码(条形码内容, 样式选项 = {}) {
  return {
    barcode: 条形码内容,
    type: 样式选项.类型 || 'EAN13',
    width: 样式选项.宽度 || 1.5,
    height: 样式选项.高度 || 50,
    ...样式选项
  };
}

/**
 * 创建分割线元素
 * @param {Object} 样式选项 - 分割线样式选项
 * @returns {Object} 分割线元素
 */
function 创建分割线(样式选项 = {}) {
  return {
    canvas: [{
      type: 'line',
      x1: 0,
      y1: 5,
      x2: 515,
      y2: 5,
      lineWidth: 样式选项.线宽 || 0.5,
      lineColor: 样式选项.颜色 || 'black',
      ...样式选项
    }],
    ...样式选项
  };
}

/**
 * 创建矩形图形元素
 * @param {Object} 样式选项 - 矩形样式选项
 * @returns {Object} 矩形图形元素
 */
function 创建矩形(样式选项 = {}) {
  return {
    canvas: [{
      type: 'rect',
      x: 样式选项.x || 0,
      y: 样式选项.y || 0,
      w: 样式选项.宽度 || 100,
      h: 样式选项.高度 || 50,
      r: 样式选项.圆角 || 0,
      lineWidth: 样式选项.线宽 || 1,
      lineColor: 样式选项.边框颜色 || 'black',
      color: 样式选项.填充颜色 || '',
      ...样式选项
    }],
    ...样式选项
  };
}

/**
 * 创建圆形图形元素
 * @param {Object} 样式选项 - 圆形样式选项
 * @returns {Object} 圆形图形元素
 */
function 创建圆形(样式选项 = {}) {
  return {
    canvas: [{
      type: 'ellipse',
      x: 样式选项.x || 50,
      y: 样式选项.y || 25,
      r1: 样式选项.半径X || 50,
      r2: 样式选项.半径Y || 25,
      lineWidth: 样式选项.线宽 || 1,
      lineColor: 样式选项.边框颜色 || 'black',
      color: 样式选项.填充颜色 || '',
      ...样式选项
    }],
    ...样式选项
  };
}

/**
 * 创建线条图形元素
 * @param {Object} 样式选项 - 线条样式选项
 * @returns {Object} 线条图形元素
 */
function 创建线条(样式选项 = {}) {
  return {
    canvas: [{
      type: 'line',
      x1: 样式选项.x1 || 0,
      y1: 样式选项.y1 || 0,
      x2: 样式选项.x2 || 100,
      y2: 样式选项.y2 || 0,
      lineWidth: 样式选项.线宽 || 1,
      lineColor: 样式选项.颜色 || 'black',
      dash: 样式选项.虚线,
      ...样式选项
    }],
    ...样式选项
  };
}

/**
 * 创建多边形图形元素
 * @param {Array} 点坐标数组 - 多边形顶点坐标数组
 * @param {Object} 样式选项 - 多边形样式选项
 * @returns {Object} 多边形图形元素
 */
function 创建多边形(点坐标数组, 样式选项 = {}) {
  return {
    canvas: [{
      type: 'polyline',
      points: 点坐标数组,
      lineWidth: 样式选项.线宽 || 1,
      lineColor: 样式选项.边框颜色 || 'black',
      closePath: 样式选项.闭合路径 !== false,
      color: 样式选项.填充颜色 || '',
      ...样式选项
    }],
    ...样式选项
  };
}

/**
 * 创建PDF链接元素
 * @param {string} 链接文本 - 链接显示文本
 * @param {string} 链接URL - 链接目标URL
 * @param {Object} 样式选项 - 链接样式选项
 * @returns {Object} 链接元素
 */
function 创建链接(链接文本, 链接URL, 样式选项 = {}) {
  const 默认样式 = {
    color: 'blue',
    decoration: 'underline'
  };
  
  return {
    text: 链接文本,
    link: 链接URL,
    ...默认样式,
    ...样式选项
  };
}

/**
 * 创建页面引用链接
 * @param {string} 链接文本 - 链接显示文本
 * @param {number} 页码 - 目标页码
 * @param {Object} 样式选项 - 链接样式选项
 * @returns {Object} 页面引用元素
 */
function 创建页面引用(链接文本, 页码, 样式选项 = {}) {
  const 默认样式 = {
    color: 'blue',
    decoration: 'underline'
  };
  
  return {
    text: 链接文本,
    pageReference: 页码,
    ...默认样式,
    ...样式选项
  };
}

/**
 * 创建目录元素
 * @param {Object} 样式选项 - 目录样式选项
 * @returns {Object} 目录元素
 */
function 创建目录(样式选项 = {}) {
  return {
    toc: {
      title: 样式选项.标题 || { text: '目录', style: 'header1' },
      numberStyle: 样式选项.编号样式 || {},
      textStyle: 样式选项.文本样式 || {},
      ...样式选项.tocOptions
    },
    ...样式选项
  };
}

/**
 * 创建文本样式对象
 * @param {Object} 样式属性 - 样式属性对象
 * @returns {Object} 样式对象
 */
function 创建文本样式(样式属性 = {}) {
  return {
    fontSize: 12,
    color: '#000000',
    font: 'Roboto',
    alignment: 'left',
    ...样式属性
  };
}

/**
 * 创建页面边距配置
 * @param {number} 左边距 - 左边距
 * @param {number} 上边距 - 上边距
 * @param {number} 右边距 - 右边距
 * @param {number} 下边距 - 下边距
 * @returns {Array} 边距数组 [left, top, right, bottom]
 */
function 创建页面边距(左边距 = 40, 上边距 = 60, 右边距 = 40, 下边距 = 60) {
  return [左边距, 上边距, 右边距, 下边距];
}

/**
 * 创建页眉
 * @param {string|Object|Function} 页眉内容 - 页眉内容或函数
 * @param {Object} 样式选项 - 页眉样式选项
 * @returns {Object|Function} 页眉配置
 */
function 创建页眉(页眉内容, 样式选项 = {}) {
  if (typeof 页眉内容 === 'function') {
    return 页眉内容;
  }
  
  return typeof 页眉内容 === 'string' ? {
    text: 页眉内容,
    alignment: 'center',
    margin: [40, 10, 40, 10],
    ...样式选项
  } : {
    ...页眉内容,
    margin: [40, 10, 40, 10],
    ...样式选项
  };
}

/**
 * 创建页脚
 * @param {string|Object|Function} 页脚内容 - 页脚内容或函数
 * @param {Object} 样式选项 - 页脚样式选项
 * @returns {Object|Function} 页脚配置
 */
function 创建页脚(页脚内容, 样式选项 = {}) {
  if (typeof 页脚内容 === 'function') {
    return 页脚内容;
  }
  
  // 默认添加页码
  if (页脚内容 === undefined) {
    return {
      text: '页码: {page} / {totalpages}',
      alignment: 'center',
      margin: [40, 10, 40, 10],
      ...样式选项
    };
  }
  
  return typeof 页脚内容 === 'string' ? {
    text: 页脚内容,
    alignment: 'center',
    margin: [40, 10, 40, 10],
    ...样式选项
  } : {
    ...页脚内容,
    margin: [40, 10, 40, 10],
    ...样式选项
  };
}

/**
 * 创建页码函数
 * @param {Object} 样式选项 - 页码样式选项
 * @returns {Function} 页码函数
 */
function 创建页码函数(样式选项 = {}) {
  return (currentPage, pageCount) => {
    const 页码文本 = 样式选项.格式 
      ? 样式选项.格式.replace('{page}', currentPage).replace('{totalpages}', pageCount)
      : `第 ${currentPage} 页，共 ${pageCount} 页`;
    
    return {
      text: 页码文本,
      alignment: 样式选项.对齐 || 'center',
      margin: [40, 10, 40, 10],
      ...样式选项
    };
  };
}

/**
 * 注册自定义字体
 * @param {Object} 字体配置 - 字体配置对象
 * @returns {Object} 字体定义对象
 */
function 注册自定义字体(字体配置 = {}) {
  const 字体定义 = {};
  
  Object.keys(字体配置).forEach(字体名称 => {
    const 字体文件 = 字体配置[字体名称];
    字体定义[字体名称] = {
      normal: 字体文件.normal || 字体文件,
      bold: 字体文件.bold,
      italics: 字体文件.italics,
      bolditalics: 字体文件.bolditalics
    };
  });
  
  return 字体定义;
}

/**
 * 创建表格样式对象
 * @param {Object} 样式属性 - 表格样式属性
 * @returns {Object} 表格样式对象
 */
function 创建表格样式(样式属性 = {}) {
  return {
    widths: 'auto',
    headerRows: 1,
    keepWithHeaderRows: 1,
    ...样式属性
  };
}

/**
 * 创建复杂的PDF文档（包含标题、段落、表格等）
 * @param {Object} 文档配置 - 文档配置对象
 * @returns {Object} PDF文档定义
 */
function 创建复杂文档(文档配置 = {}) {
  const 内容 = [];
  
  // 添加目录（如果需要）
  if (文档配置.包含目录) {
    内容.push(创建目录(文档配置.目录样式));
    // 添加页面断开
    内容.push({ text: '', pageBreak: 'after' });
  }
  
  // 添加标题
  if (文档配置.标题) {
    内容.push(创建标题(文档配置.标题, 1, { margin: [0, 0, 0, 20] }));
  }
  
  // 添加副标题
  if (文档配置.副标题) {
    内容.push(创建标题(文档配置.副标题, 2, { margin: [0, 0, 0, 15] }));
  }
  
  // 添加作者信息
  if (文档配置.作者) {
    内容.push(创建文本元素(`作者: ${文档配置.作者}`, { 
      margin: [0, 0, 0, 10], 
      fontSize: 10,
      color: '#666'
    }));
  }
  
  // 添加日期
  if (文档配置.日期) {
    内容.push(创建文本元素(`日期: ${文档配置.日期}`, { 
      margin: [0, 0, 0, 20], 
      fontSize: 10,
      color: '#666'
    }));
  }
  
  // 添加摘要
  if (文档配置.摘要) {
    内容.push(创建标题('摘要', 2, { margin: [0, 20, 0, 10] }));
    内容.push(创建文本元素(文档配置.摘要, { margin: [0, 0, 0, 20] }));
  }
  
  // 添加目录（如果需要在文档开始处）
  if (文档配置.目录 && !文档配置.包含目录) {
    内容.push(创建标题('目录', 2, { margin: [0, 20, 0, 10] }));
    内容.push(创建目录(文档配置.目录样式));
    内容.push({ text: '', pageBreak: 'after' });
  }
  
  // 添加简介
  if (文档配置.简介) {
    内容.push(创建文本元素(文档配置.简介, { margin: [0, 0, 0, 20] }));
  }
  
  // 添加正文段落
  if (文档配置.段落 && Array.isArray(文档配置.段落)) {
    文档配置.段落.forEach((段落, 索引) => {
      内容.push(创建文本元素(段落, { margin: [0, 0, 0, 索引 === 文档配置.段落.length - 1 ? 20 : 10] }));
    });
  }
  
  // 添加表格
  if (文档配置.表格) {
    内容.push(创建标题(文档配置.表格标题 || '表格', 3, { margin: [0, 20, 0, 10] }));
    内容.push(创建表格(文档配置.表格数据, {
      margin: [0, 10, 0, 20],
      ...(文档配置.表格样式 || {})
    }));
  }
  
  // 添加列表
  if (文档配置.列表) {
    内容.push(创建标题(文档配置.列表标题 || '列表', 3, { margin: [0, 20, 0, 10] }));
    内容.push(创建列表(文档配置.列表项, {
      margin: [0, 10, 0, 20],
      ...(文档配置.列表样式 || {})
    }));
  }
  
  // 添加图片
  if (文档配置.图片) {
    内容.push(创建标题(文档配置.图片标题 || '图片', 3, { margin: [0, 20, 0, 10] }));
    内容.push(创建图片元素(文档配置.图片, {
      margin: [0, 10, 0, 20],
      alignment: 'center',
      ...(文档配置.图片样式 || {})
    }));
  }
  
  // 添加图表（图表是自定义对象）
  if (文档配置.图表) {
    内容.push(创建标题(文档配置.图表标题 || '图表', 3, { margin: [0, 20, 0, 10] }));
    内容.push(文档配置.图表);
  }
  
  // 添加引用
  if (文档配置.引用) {
    内容.push(创建标题('引用', 2, { margin: [0, 20, 0, 10] }));
    内容.push(创建文本元素(文档配置.引用, {
      margin: [40, 10, 40, 20],
      fontSize: 11,
      color: '#444',
      italics: true
    }));
  }
  
  // 创建文档定义
  return 创建PDF文档定义(内容, {
    页面尺寸: 文档配置.页面尺寸 || 'A4',
    页面方向: 文档配置.页面方向 || 'portrait',
    页面边距: 文档配置.页面边距 || 创建页面边距(),
    页头: 文档配置.页头 || 创建页眉(文档配置.页眉文本),
    页脚: 文档配置.页脚 || 创建页脚(),
    默认样式: 文档配置默认样式 || 创建文本样式(),
    样式: 文档配置.样式 || {},
    表格布局: 文档配置.表格布局 || {},
    背景: 文档配置.背景,
    页面断开处理函数: 文档配置.页面断开处理函数
  });
}

/**
 * 创建样式系统对象
 * @param {Object} 样式定义 - 样式定义对象
 * @returns {Object} 样式系统对象
 */
function 创建样式系统(样式定义 = {}) {
  const 基础样式 = {
    header1: {
      fontSize: 24,
      bold: true,
      margin: [0, 20, 0, 10]
    },
    header2: {
      fontSize: 20,
      bold: true,
      margin: [0, 15, 0, 10]
    },
    header3: {
      fontSize: 16,
      bold: true,
      margin: [0, 12, 0, 8]
    },
    header4: {
      fontSize: 14,
      bold: true,
      margin: [0, 10, 0, 6]
    },
    header5: {
      fontSize: 12,
      bold: true,
      margin: [0, 8, 0, 4]
    },
    header6: {
      fontSize: 11,
      bold: true,
      margin: [0, 6, 0, 3]
    },
    paragraph: {
      margin: [0, 0, 0, 10],
      fontSize: 12
    },
    small: {
      fontSize: 10
    },
    large: {
      fontSize: 14
    },
    bold: {
      bold: true
    },
    italic: {
      italics: true
    },
    center: {
      alignment: 'center'
    },
    right: {
      alignment: 'right'
    },
    justify: {
      alignment: 'justify'
    },
    tableHeader: {
      bold: true,
      fontSize: 12,
      color: 'black',
      fillColor: '#CCCCCC'
    }
  };
  
  return { ...基础样式, ...样式定义 };
}

/**
 * 创建段落样式系统
 * @param {Object} 段落样式定义 - 段落样式定义对象
 * @returns {Object} 段落样式系统
 */
function 创建段落样式(段落样式定义 = {}) {
  const 基础段落样式 = {
    indented: {
      margin: [20, 5, 0, 5]
    },
    noMargin: {
      margin: [0, 0, 0, 0]
    },
    spaced: {
      margin: [0, 15, 0, 15]
    }
  };
  
  return { ...基础段落样式, ...段落样式定义 };
}

/**
 * 创建页面事件处理函数
 * @param {Object} 事件处理 - 事件处理函数对象
 * @returns {Object} 页面事件处理对象
 */
function 创建页面事件(事件处理 = {}) {
  return {
    // 页面初始化事件
    onPageInit: 事件处理.页面初始化,
    // 页面渲染前事件
    onPageAdded: 事件处理.页面添加,
    // 页面渲染后事件
    afterPageInit: 事件处理.页面初始化后,
    ...事件处理
  };
}

/**
 * 创建页面断开控制函数
 * @param {Function} 判断函数 - 判断是否需要页面断开的函数
 * @returns {Function} 页面断开控制函数
 */
function 创建页面断开控制(判断函数) {
  return 判断函数 || function(currentNode, followingNodesOnPage) {
    return currentNode.headlineLevel === 1 && followingNodesOnPage.length === 0;
  };
}

/**
 * 创建水印元素
 * @param {string} 水印文本 - 水印文本
 * @param {Object} 样式选项 - 水印样式选项
 * @returns {Object} 水印元素
 */
function 创建水印(水印文本, 样式选项 = {}) {
  const 默认样式 = {
    text: 水印文本,
    fontSize: 48,
    color: 'rgba(128, 128, 128, 0.3)',
    opacity: 0.3,
    bold: true,
    italics: true,
    absolutePosition: {
      x: 150,
      y: 300
    },
    angle: -30
  };
  
  return { ...默认样式, ...样式选项 };
}

/**
 * 创建绝对定位元素
 * @param {Object|Array} 元素 - 要定位的元素
 * @param {number} x - X坐标
 * @param {number} y - Y坐标
 * @param {Object} 样式选项 - 其他样式选项
 * @returns {Object|Array} 绝对定位元素
 */
function 创建绝对定位元素(元素, x, y, 样式选项 = {}) {
  if (Array.isArray(元素)) {
    return 元素.map(item => ({
      ...item,
      absolutePosition: { x, y },
      ...样式选项
    }));
  }
  
  return {
    ...元素,
    absolutePosition: { x, y },
    ...样式选项
  };
}

/**
 * 导出PDF模块
 */
module.exports = {
  // 核心功能
  创建PDF文档定义,
  生成并保存PDF,
  生成PDFBuffer,
  生成PDFBase64,
  流式输出PDF到响应,
  流式输出PDF到流,
  
  // 文本和段落元素
  创建文本元素,
  创建段落,
  创建标题,
  
  // 媒体和图形元素
  创建图片元素,
  创建二维码,
  创建条形码,
  创建分割线,
  
  // 图形绘制元素
  创建矩形,
  创建圆形,
  创建线条,
  创建多边形,
  
  // 表格相关
  创建表格,
  创建表格布局,
  创建表格样式,
  
  // 列表和列
  创建列表,
  创建列,
  
  // 导航和链接
  创建链接,
  创建页面引用,
  
  // 文档结构
  创建复杂文档,
  创建目录,
  
  // 样式系统
  创建文本样式,
  创建样式系统,
  创建段落样式,
  
  // 页面布局
  创建页面边距,
  创建页眉,
  创建页脚,
  创建页码函数,
  
  // 高级功能
  创建水印,
  创建绝对定位元素,
  创建页面断开控制,
  创建页面事件,
  注册自定义字体,
  
  // PDF读取与解析功能
  读取PDF文件,
  从Buffer读取PDF,
  解析PDF文本内容,
  提取PDF页面,
  提取PDF图片,
  获取PDF页面数,
  获取PDF元数据,
  
  // PDF操作功能
  合并PDF文档,
  分割PDF文档,
  添加PDF水印,
  添加PDF页码,
  PDF加密,
  PDF解密,
  旋转PDF页面,
  压缩PDF文件,
  
  // PDF转换功能
  PDF转图片,
  PDF转HTML,
  PDF转文本,
  比较PDF文档,

  // 常量
  页面尺寸: {
    A3: 'A3',
    A4: 'A4',
    A5: 'A5',
    LEGAL: 'LEGAL',
    LETTER: 'LETTER',
    TABLOID: 'TABLOID'
  },
  页面方向: {
    纵向: 'portrait',
    横向: 'landscape'
  },
  对齐方式: {
    左对齐: 'left',
    右对齐: 'right',
    居中: 'center',
    两端对齐: 'justify'
  },
  列表类型: {
    无序列表: 'unordered',
    有序列表: 'ordered'
  },
  条形码类型: {
    EAN13: 'EAN13',
    EAN8: 'EAN8',
    UPCA: 'UPCA',
    UPCE: 'UPCE',
    CODE39: 'CODE39',
    CODE128: 'CODE128'
  },
  
  // 获取原始库引用
  获取原始pdfmake: () => pdfMake,
  

};